package com.yidu.hbatsams.action.AtsData;
import com.yidu.hbatsams.domain.*;
import com.yidu.hbatsams.service.*;
import com.yidu.hbatsams.service.emp.AtsEmpAthleteService;
import com.yidu.hbatsams.utils.AtsDataShowTree;
import com.yidu.hbatsams.utils.redis.RedisUtil;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.util.*;

 /*
 * @Author 谭俊
 * @Description //TODO 数据对比展示
 * @Date 16:19 2019/12/24 0024
 * @Param 
 * @return 
 **/
@Controller
@RequestMapping("/AtsDataShowController")
public class AtsDataShowController {

    List<Map<String,Object>> ex = new  ArrayList<Map<String,Object>>();

    /**
     * 运动员service
     */
    @Resource
    private AtsEmpAthleteService atsEmpAthleteService;
    /**
     * 体育项目关联指标service
     */
    @Resource
    private AtsBaseSportItemService atsBaseSportItemService;

     /**
     * 数据批次service
     */
      @Resource
     private AtsDataBatchService atsDataBatchService;

     /**
     * 实际数据service
     */
      @Resource
      private AtsDataService atsDataService;

    /**
     * 体育项目service
     */
    @Resource
    private AtsBaseSportService atsBaseSportService;

     /**
      * redis
      */
     @Resource
    private RedisUtil redisUtil;

     /**
      *下载导出
      * @param response
      */
     @RequestMapping("download")
     public void download(HttpServletResponse response){

         //导出工具类
         ExcelTest es=new ExcelTest();

         es.sds(ex,response);

     }

    /**
     * 根据运动员查体育项目
     * @param
     * @return
     */
    @RequestMapping("selectitem")
    @ResponseBody
    public  Map<String,Object> selectitem(String athleteId){
        //i=1
        int i=1;
        //创建map集合
        Map<String,Object> map=new HashMap<String,Object>();
        //创建运动项目list集合
        List<AtsBaseSport> lis=new ArrayList<AtsBaseSport>();
        //创建运动员list集合
        List<AtsEmpAthlete> sd=new ArrayList<AtsEmpAthlete>();
        //运动员不等于-1
        if (athleteId.indexOf(",")!=-1){
            //循环去掉运动员id,
            for (String s : athleteId.split(",")) {
                //调用根据运动员id查询
                sd.add( atsEmpAthleteService.findById(Integer.valueOf(s)));
                //根据运动员id查询体育项目
                lis.add(atsBaseSportService.selectAth(Integer.valueOf(s)));
            }

        }else{
            sd.add( atsEmpAthleteService.findById(Integer.valueOf(athleteId)));
            lis.add(atsBaseSportService.selectAth(Integer.valueOf(athleteId)));

        }
        //循环运动项目
        for (AtsBaseSport li : lis) {
               //循环的项目id不等于查询的项目id
            if(li.getSportId()!=lis.get(0).getSportId()) {
            //设置i等于0
                i=0;
            }
        }
        //当i等于0
        if(i==0){
            //设置num 0
            map.put("num",0);

        }else{
            map.put("num",1);
            map.put("sportId",lis.get(0).getSportId());
            map.put("data",sd);
        }

        return map;
    }


     /**
      * 根据批次ID查批次
      * @param batchId 批次ID
      * @return
      */
     @RequestMapping("selectBatchId")
     @ResponseBody
     public AtsDataBatch selectBatchId(String batchId){
         //创建批次对象
         AtsDataBatch atsDataBatch=new AtsDataBatch();
         //设置批次的id
         atsDataBatch.setBatchId(Integer.valueOf(batchId));
          //调用service方法查询
         return  atsDataBatchService.selectAtsDataCondition(atsDataBatch);
     }


     /**
      * 根据体育项目查询运动员  返回list
      * @param atsEmpAthlete 运动员对象
      * @param athleteIds 运动员id
      * @return
      */
    @RequestMapping("selectBysportId")
    @ResponseBody
    public List<Map<String,Object>> selectBysportId(AtsEmpAthlete atsEmpAthlete,String athleteIds){

         //调用运动员service查询体育项目
        List<AtsEmpAthlete> list=atsEmpAthleteService.selectBysportId(atsEmpAthlete);

        //定义map集合
        List<Map<String,Object>> lis=new ArrayList<Map<String,Object>>();
        //迭代循环运动员集合
        for (Iterator<AtsEmpAthlete> iterator = list.iterator(); iterator.hasNext(); ) {
            AtsEmpAthlete next =  iterator.next();
            //定义map集合
            Map<String,Object> map = new HashMap<>();
            //加入运动员名字
            map.put("name",next.getAthleteName());
            //加入运动员id
            map.put("value",next.getAthleteId());
           //运动员传值id不等于空
            if(!StringUtils.isEmpty(athleteIds)){
                //下标不等于-1
                if(athleteIds.indexOf(",")!=-1) {
                    //分割字符串数组保存
                    String[] arr = athleteIds.split(",");
                    //循环数组
                    for (String str : arr) {
                        //迭代循环的id等于循环的数组
                        if (next.getAthleteId()==Integer.valueOf(str)){
                            //加入selected为true
                            map.put("selected",true);
                            //退出
                            break;
                        }
                    }
                }else {
                      //迭代循环的id等于传值的id
                    if (next.getAthleteId()==Integer.valueOf(athleteIds)){
                        //加入selected为true
                        map.put("selected",true);

                    }
                }
            }
            //加入到lim集合里
            lis.add(map);

        }
        //返回lim集合
        return lis;
    }


    /**
     * 根据体育项目查询指标
     * @param sportId 体育项目ID
     * @return 树状参数
     */
    @RequestMapping("selectAtsBaseItem")
    @ResponseBody
    public List<Map<String,Object>> selectAtsBaseItem(Integer sportId){

         //rids缓存
        List<AtsBaseSportItem> lsit = (List<AtsBaseSportItem>)redisUtil.get("BaesItem"+sportId);
        //缓存如果等于空
        if(lsit==null){
            //调用体育指标service查询
            List<AtsBaseSportItem> atsBaseItemList=atsBaseSportItemService.findId(sportId,1);
            //加入缓存
            redisUtil.set("BaesItem"+sportId,atsBaseItemList);

            //新建树状图工具集合
            List<AtsDataShowTree> atsBaseItemTreeList = new ArrayList<>();

            //循环数据库数据
            for (AtsBaseSportItem atsBaseSportItem : atsBaseItemList) {
                  //新建树状图对象
                AtsDataShowTree atsBaseItemTree = new AtsDataShowTree();
                   //指标不等于空
                if(atsBaseSportItem.getAtsBaseItem()!=null) {
                    //设置当前id值为指标id
                    atsBaseItemTree.setId(atsBaseSportItem.getAtsBaseItem().getItemId().toString());
                    //名称
                    atsBaseItemTree.setLabel(atsBaseSportItem.getAtsBaseItem().getItemExp());
                    //外键
                    atsBaseItemTree.setValue(atsBaseSportItem.getAtsBaseItem().getParentId().toString());
                    //存入树状图工具集合
                    atsBaseItemTreeList.add(atsBaseItemTree);

                }
            }
            //定义map
            Map<String,Object> map=new HashMap<>();
            //加入label 指标
            map.put("label","指标");
            //id 为0
            map.put("id",0);
            //创建树形children
            map.put("children",createTree(atsBaseItemTreeList));

             //创建lim集合
            List<Map<String,Object>> lis=new ArrayList<Map<String,Object>>();

             //添加到集合
            lis.add(map);

            return lis;

        }else {

            //新建树状图工具集合
            List<AtsDataShowTree> atsBaseItemTreeList = new ArrayList<>();
            //缓存集合不等于空
            if(lsit!=null){

                //循环体育项目指标数据
                for (AtsBaseSportItem atsBaseSportItem : lsit) {
                    //创建树对象
                    AtsDataShowTree atsBaseItemTree = new AtsDataShowTree();
                    //指标不等于空
                    if (atsBaseSportItem.getAtsBaseItem() != null) {
                        //当前id
                        atsBaseItemTree.setId(atsBaseSportItem.getAtsBaseItem().getItemId().toString());
                        //名称
                        atsBaseItemTree.setLabel(atsBaseSportItem.getAtsBaseItem().getItemExp());
                        //外键
                        atsBaseItemTree.setValue(atsBaseSportItem.getAtsBaseItem().getParentId().toString());
                        //存入树状图工具集合
                        atsBaseItemTreeList.add(atsBaseItemTree);


                    }
                }
            }
            //创建map集合
            Map<String, Object> map = new HashMap<>();
            //放入label指标
            map.put("label", "指标");
           //放入id
            map.put("id", 0);
            //放入children加入工具方法
            map.put("children", createTree(atsBaseItemTreeList));
            //创建lim集合
            List<Map<String, Object>> lis = new ArrayList<Map<String, Object>>();
            //添加map
            lis.add(map);
             //返回
            return lis;


        }

    }

     /**
      * 查比较数据  返回list
      * @param
      * @return
      */
     @RequestMapping("select")
     @ResponseBody
     public List<Map<String,Object>> select(String yudo,String zhibiao,String cishu,Integer sportId){
           //分割zhibiao字符串,
         String[] zhi=zhibiao.split(",");
         //根据id查询体育项目指标
         List<AtsBaseSportItem> atsBaseItemList=atsBaseSportItemService.findId(sportId,1);
           //创建集合lim
         List<Map<String,Object>> lis=new ArrayList<Map<String,Object>>();
         //分割次数字符串
         String[] arr=cishu.split(",");
         //循环次数
         for (String s : arr) {
             //不等于空String
             if (!StringUtils.isEmpty(s)){
                 //创建树形list集合
                 List<AtsDataShowTree> atsBaseItemTreeList=new ArrayList<>();
                 //循环查询出来体育项目指标数据
                 for (AtsBaseSportItem atsBaseSportItem : atsBaseItemList) {
                     //创建树形对象
                     AtsDataShowTree atsBaseItemTree=new AtsDataShowTree();
                     //循环指标不等于空
                     if(atsBaseSportItem.getAtsBaseItem()!=null) {
                         //当前id
                         atsBaseItemTree.setId(atsBaseSportItem.getAtsBaseItem().getItemId().toString());
                         //名称
                         atsBaseItemTree.setName(atsBaseSportItem.getAtsBaseItem().getItemExp());
                         //外键
                         atsBaseItemTree.setTitle(atsBaseSportItem.getAtsBaseItem().getParentId().toString());
                         //指标单位
                         atsBaseItemTree.setLabel(atsBaseSportItem.getAtsBaseItem().getItemUnit());
                         //加入集合
                         atsBaseItemTreeList.add(atsBaseItemTree);
                     }

                 }
                 //将加入的集合放入工具
                 List<AtsDataShowTree> atsBaseItemTreeLists = createTree2(atsBaseItemTreeList);
                 //创建批次对象
                 AtsDataBatch atsDataBatch=new AtsDataBatch();
                 //设置批次id
                 atsDataBatch.setBatchId(Integer.valueOf(s));
                 //使用批次service查询批次 批次对象
                 atsDataBatch=  atsDataBatchService.selectAtsDataCondition(atsDataBatch);
                 //使用实际指标数据service查询AtsData
                 List<AtsData> atsData=atsDataService.atsDataByIdBatch(Integer.valueOf(s));
                 //循环实际指标数据
                 for (int i=0; i<atsData.size();i++) {
                     //定义int等于0
                     int fg=0;
                     //循环分割的指标
                     for (String  str: zhi) {
                         //如果不等于空
                         if (!StringUtils.isEmpty(str)) {
                             if (atsData.get(i).getItemId().toString() .equals( str)) {
                                 //变量等于1
                                 fg = 1;
                             }
                         }
                     }
                     //如果等于0
                     if(fg==0){
                         //移除i
                         atsData.remove(i);
                         //i--
                         i--;
                     }
                 }
                 //创建map集合
                 Map<String,Object> mapex=new HashMap<String,Object>();
                 //存入批次运动员数据name
                 mapex.put("name",atsDataBatch.getAthleteName()+"("+atsDataBatch.getBatchDate()+")");
                 //存入data
                 mapex.put("data",atsData);
                 //添加到lim
                 ex.add(mapex);
                 //放入树状图
                 List<AtsDataShowTree> jieguo=sdf(atsBaseItemTreeLists,atsData);
                 //创建map集合
                 Map<String,Object> map=new HashMap<String,Object>();
                 //如果截取的长度等于1
                 if(yudo.split(",").length==1){
                     //设置批次的名称
                     map.put("name",atsDataBatch.getBatchName());
                 }else {
                     //设置运动员名称
                     map.put("name", atsDataBatch.getAthleteName());
                 }
                 //设置运动员名称和时间
                 map.put("names", atsDataBatch.getAthleteName()+"("+atsDataBatch.getBatchDate()+")");
                 //设置data jieguo
                 map.put("data",jieguo);

                 //添加
                 lis.add(map);
             }

         }
         //添加到lim
         ex=lis;
        //返回lim集合
         return lis;
     }



    /**
     * 根据批次id查实际数据
     * @param atsDataBatch 实际数据
     * @param batchIds 批次id
     * @return
     */
    @RequestMapping("selectAtsDataComparison")
    @ResponseBody
    public List<Map<String,Object>> selectAtsDataComparison(AtsDataBatch atsDataBatch,Integer batchIds){

        //查询批次
        List<AtsDataBatch> list=atsDataBatchService.selectAtsDataComparison(atsDataBatch);
        //创建集合lim
        List<Map<String,Object>> lis=new ArrayList<Map<String,Object>>();
        //迭代循环批次
        for (Iterator<AtsDataBatch> iterator = list.iterator(); iterator.hasNext(); ) {
            AtsDataBatch next =  iterator.next();
            //创建map集合
            Map<String,Object> map=new HashMap<>();
            //加入名字 和批次时间
            map.put("name",next.getAthleteName()+"("+next.getBatchDate()+")");
            //加入批次id
            map.put("value",next.getBatchId());
            //如果批次id不等于空
            if(!StringUtils.isEmpty(batchIds)){
                //迭代循环的批次id等于传值id
                if(next.getBatchId()==batchIds){
                    //加入selected true
                    map.put("selected",true);
                }
            }
            //添加到lim
            lis.add(map);
        }
        //返回lim集合
        return lis;
    }






     /**
      * 树状图工具
      * @param atsBaseItemTreeLists
      * @param atsData
      * @return
      */
    public  List<AtsDataShowTree> sdf(  List<AtsDataShowTree> atsBaseItemTreeLists ,List<AtsData> atsData){

        for (int i=0;i<atsBaseItemTreeLists.size() ;i++ ) {

            if (atsBaseItemTreeLists.get(i).getChildren().size()>0){

                sdf(atsBaseItemTreeLists.get(i).getChildren(), atsData);

                if (atsBaseItemTreeLists.get(i).getChildren().size()==0){

                    atsBaseItemTreeLists.remove(i);
                    i--;
                }
            }else{
                int j=0;

                for (AtsData s : atsData) {

                    if(atsBaseItemTreeLists.get(i).getId().equals(s.getItemId().toString())){

                        atsBaseItemTreeLists.get(i).setValue(s.getValueFact().toString());
                        j=1;
                    }
                }
                if (j==0){

                    atsBaseItemTreeLists.remove(i);

                    i--;
                }
            }

        }

        return atsBaseItemTreeLists;
    }


    /**
     * 下拉树
     * @param nodes
     * @return
     */
    public List<AtsDataShowTree> createTree(List<AtsDataShowTree> nodes) {

        if (nodes == null || nodes.size() < 0){
            return null;
        }
        List<AtsDataShowTree> nodeList = new ArrayList<>();// 根节点自定义，但是要和pid对应好
        // 将所有节点添加到多叉树中
        for (AtsDataShowTree node : nodes) {
            if (node.getValue().equals("0")) {// 根节点自定义，但是要和pid对应好
                // 向根添加一个节点
                nodeList.add(node);
            } else {
                for (AtsDataShowTree item : nodes) {
                    if (item.getId().equals(node.getValue())) {
                        item.getChildren().add(node);

                        break ;
                    }
                }
            }

        }

        return nodeList;
    }

    /**
     * 下拉树2
     * @param nodes
     * @return
     */
    public List<AtsDataShowTree> createTree2(List<AtsDataShowTree> nodes) {

        if (nodes == null || nodes.size() < 0){
            return null;
        }
        List<AtsDataShowTree> nodeList = new ArrayList<>();// 根节点自定义，但是要和pid对应好
        // 将所有节点添加到多叉树中
        for (AtsDataShowTree node : nodes) {
            if (node.getTitle().equals("0")) {// 根节点自定义，但是要和pid对应好
                // 向根添加一个节点
                nodeList.add(node);
            } else {
                for (AtsDataShowTree item : nodes) {
                    if (item.getId().equals(node.getTitle())) {
                        item.getChildren().add(node);

                        break ;
                    }
                }
            }

        }

        return nodeList;
    }

    /**
     * 下拉树3
     * @param nodes
     * @return
     */
    public List<AtsDataShowTree> createTree3(List<AtsDataShowTree> nodes) {

        if (nodes == null || nodes.size() < 0){
            return null;
        }
        List<AtsDataShowTree> nodeList = new ArrayList<>();// 根节点自定义，但是要和pid对应好
        // 将所有节点添加到多叉树中
        for (AtsDataShowTree node : nodes) {

            if (node.getName().equals("0")) {// 根节点自定义，但是要和pid对应好
                // 向根添加一个节点
                nodeList.add(node);
            } else {
                for (AtsDataShowTree item : nodes) {
                    if (item.getId().equals(node.getName())) {
                        item.getChildren().add(node);
                        break ;
                    }
                }
            }

        }

        return nodeList;
    }





}
